// 网络请求封装
import config from '../config.js'
import store from '../../store'
import mockData from '../mock/index.js'  // 直接导入mock数据

// 后端API基础URL
const BASE_URL = config.apiBaseUrl

// 记录错误信息
const logError = (title, msg) => {
  console.error(title, msg)
  
  // 记录到本地日志
  try {
    const logs = uni.getStorageSync('request_error_logs') || []
    logs.unshift({
      time: new Date().toISOString(),
      title,
      message: typeof msg === 'object' ? JSON.stringify(msg) : msg
    })
    
    // 只保留最近50条日志
    if (logs.length > 50) {
      logs.length = 50
    }
    
    uni.setStorageSync('request_error_logs', logs)
  } catch (e) {
    console.error('记录错误日志失败:', e)
  }
}

/**
 * 封装请求方法
 * @param {Object} options - 请求选项
 * @returns {Promise} - 返回Promise对象
 */
function request(options) {
  // 获取配置
  const TIMEOUT = config.timeout || 10000
  
  return new Promise((resolve, reject) => {
    // 完整URL - 修复URL拼接逻辑，确保路径正确
    let url;
    if (/^(http|https):\/\//.test(options.url)) {
      // 如果是完整URL，直接使用
      url = options.url;
    } else {
      // 否则拼接BASE_URL，确保路径正确
      // 移除URL中的多余斜杠，避免出现双斜杠
      const baseUrl = BASE_URL.endsWith('/') ? BASE_URL.slice(0, -1) : BASE_URL;
      const apiPath = options.url.startsWith('/') ? options.url : '/' + options.url;
      url = baseUrl + apiPath;
    }
    
    // 打印请求详情
    console.log('发起请求:', {
      url,
      method: options.method || 'GET',
      data: options.data || {}
    });
    
    // 是否使用模拟数据
    if (config.useMock) {
      console.log('使用模拟数据模式');
      // 模拟响应数据
      const mockResponse = handleMockRequest(options);
      setTimeout(() => {
        resolve(mockResponse);
      }, 300);
      return;
    }
    
    // 获取存储的token - 修复token获取方式，从xuetang_token中获取
    let token = uni.getStorageSync('xuetang_token')
    
    // 如果没有token，再尝试从token键获取
    if (!token) {
      token = uni.getStorageSync('token')
    }
    
    // 如果store存在且store.state.user存在，则尝试从store获取token
    if (store && store.state && store.state.user) {
      token = token || store.state.user.token
    }
    
    // 请求头
    const header = {
      'Content-Type': options.contentType || 'application/json',
      ...options.header
    }
    
    // 如果有token，添加到请求头
    if (token) {
      header['Authorization'] = `Bearer ${token}`
      
      // 从token中获取用户ID (假设token格式为 wx_用户ID_token)
      const userIdMatch = token.match(/wx_(\w+)_token/)
      if (userIdMatch && userIdMatch[1]) {
        // 添加X-User-ID头部
        header['X-User-ID'] = userIdMatch[1]
      } else {
        // 尝试从storage中获取用户ID
        const userInfo = uni.getStorageSync('xuetang_user_info')
        if (userInfo && userInfo.id) {
          header['X-User-ID'] = userInfo.id.toString()
        }
      }
    }
    
    // 创建请求对象
    const requestTask = uni.request({
      url,
      data: options.data,
      method: options.method || 'GET',
      header,
      timeout: TIMEOUT,
      success: (res) => {
        // 详细记录请求响应信息
        console.log('请求响应:', {
          url,
          method: options.method || 'GET',
          statusCode: res.statusCode,
          data: res.data
        });
        
        // 请求成功
        if (res.statusCode === 200) {
          // 业务成功
          if (res.data.code === 0 || res.data.code === 200) {
            resolve(res.data);
          } 
          // token过期
          else if (res.data.code === 401) {
            // 清除token并提示重新登录
            uni.removeStorageSync('xuetang_token');
            uni.removeStorageSync('xuetang_user_info');
            
            uni.showToast({
              title: '登录已过期，请重新登录',
              icon: 'none'
            });
            
            // 跳转到登录页
            setTimeout(() => {
              uni.navigateTo({
                url: '/pages/login/index'
              });
            }, 1500);
            
            reject(res.data);
          } 
          // 其他业务错误
          else {
            if (options.showError !== false) {
              uni.showToast({
                title: res.data.message || '请求失败',
                icon: 'none'
              });
            }
            
            reject(res.data);
          }
        } 
        // HTTP 错误
        else {
          logError('请求失败，状态码:', res.statusCode);
          logError('请求URL:', url);
          logError('请求方法:', options.method || 'GET');
          logError('请求数据:', options.data);
          logError('请求头:', header);
          logError('响应数据:', res.data);
          
          if (options.showError !== false) {
            uni.showToast({
              title: `请求失败 (${res.statusCode})`,
              icon: 'none'
            });
          }
          
          reject({ code: res.statusCode, message: '请求失败', data: res.data });
        }
      },
      fail: (err) => {
        logError('请求失败:', err);
        logError('请求URL:', url);
        logError('请求方法:', options.method || 'GET');
        
        if (options.showError !== false) {
          uni.showToast({
            title: '网络请求失败，请检查网络连接',
            icon: 'none'
          });
        }
        
        // 尝试存储失败的请求，以便后续重试
        try {
          const pendingRequests = uni.getStorageSync('pending_requests') || [];
          // 只存储POST、PUT、DELETE请求，因为这些会改变数据
          if (['POST', 'PUT', 'DELETE'].includes((options.method || 'GET').toUpperCase())) {
            pendingRequests.push({
              url: options.url,
              method: options.method,
              data: options.data,
              timestamp: Date.now()
            });
            uni.setStorageSync('pending_requests', pendingRequests);
          }
        } catch (e) {
          console.error('存储待处理请求失败:', e);
        }
        
        reject(err);
      }
    });
    
    // 支持取消请求
    if (options.getTask) {
      options.getTask(requestTask);
    }
  })
}

/**
 * GET请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求参数
 * @param {Object} options - 额外选项
 * @returns {Promise} - 返回Promise对象
 */
export function get(url, data = {}, options = {}) {
  return request({
    url,
    data,
    method: 'GET',
    ...options
  })
}

/**
 * POST请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求数据
 * @param {Object} options - 额外选项
 * @returns {Promise} - 返回Promise对象
 */
export function post(url, data = {}, options = {}) {
  return request({
    url,
    data,
    method: 'POST',
    ...options
  })
}

/**
 * PUT请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求数据
 * @param {Object} options - 额外选项
 * @returns {Promise} - 返回Promise对象
 */
export function put(url, data = {}, options = {}) {
  return request({
    url,
    data,
    method: 'PUT',
    ...options
  })
}

/**
 * DELETE请求
 * @param {String} url - 请求地址
 * @param {Object} data - 请求数据
 * @param {Object} options - 额外选项
 * @returns {Promise} - 返回Promise对象
 */
export function del(url, data = {}, options = {}) {
  return request({
    url,
    data,
    method: 'DELETE',
    ...options
  })
}

/**
 * 处理模拟请求，返回模拟数据
 * @param {Object} options - 请求选项
 * @returns {Object} - 模拟响应数据
 */
function handleMockRequest(options) {
  console.log('处理模拟请求:', options);
  
  // 提取请求路径
  const path = options.url.replace(/^.*\/api\//, '');
  const method = options.method || 'GET';
  const data = options.data || {};
  
  // 默认成功响应
  const successResponse = {
    code: 0,
    message: '操作成功',
    data: null
  };
  
  // 血糖记录相关接口
  if (path.includes('bloodSugar')) {
    // 添加血糖记录
    if (path === 'bloodSugar/records' && method === 'POST') {
      const records = uni.getStorageSync('bloodSugarRecords') || [];
      const newRecord = {
        id: new Date().getTime(),
        userId: data.userId,
        value: data.value,
        measureTime: data.measureTime,
        type: data.measureType,
        remark: data.remark,
        createTime: new Date().toISOString()
      };
      records.unshift(newRecord);
      uni.setStorageSync('bloodSugarRecords', records);
      
      return {
        code: 0,
        message: '添加成功',
        data: newRecord
      };
    }
    
    // 获取血糖记录列表
    if (path === 'bloodSugar/records' && method === 'GET') {
      const records = uni.getStorageSync('bloodSugarRecords') || [];
      return {
        code: 0,
        message: '获取成功',
        data: {
          records: records,
          total: records.length
        }
      };
    }
  }
  
  // 默认返回成功响应
  return successResponse;
}

// 导出默认的请求函数
export default request 